// app.js
App({
  onLaunch() {
    // 展示本地存储能力
    const logs = wx.getStorageSync('logs') || []
    logs.unshift(Date.now())
    wx.setStorageSync('logs', logs)

    // 登录
    wx.login({
      success: res => {
        // 发送 res.code 到后台换取 openId, sessionKey, unionId
        console.log('微信登录成功:', res.code)
      }
    })

    // 检查管理员登录状态
    const adminToken = wx.getStorageSync('adminToken')
    const adminInfo = wx.getStorageSync('adminInfo')
    if (adminToken && adminInfo) {
      this.globalData.token = adminToken
      this.globalData.adminInfo = adminInfo
      this.globalData.isUserMode = false
      
      console.log('应用启动时恢复管理员状态:', {
        token: adminToken ? adminToken.substring(0, 10) + '...' : null,
        adminInfo: adminInfo ? { id: adminInfo.id, username: adminInfo.username } : null
      })
      
      // 验证token是否有效
      this.checkToken()
    } else {
      console.log('应用启动时没有管理员登录状态')
    }

    // 启动消息轮询
    this.startMessagePolling()
  },

  globalData: {
    userInfo: null,
    token: null,
    adminInfo: null, // 管理员信息
    // 管理员端API
    baseUrl: 'https://crm.user.023ent.net/api/scanwork',
    // 用户端API
    userApiUrl: 'https://crm.user.023ent.net/api/userex',
    // 用户端token
    userToken: null,
    // 是否用户模式
    isUserMode: false,
    messagePollingTimer: null,
    lastMessageCheck: 0,
    unreadCount: 0
  },

  // 管理员端请求方法
  request(options) {
    const that = this
    return new Promise((resolve, reject) => {
      // 优先使用globalData中的token，如果没有则从存储中获取
      const token = that.globalData.token || wx.getStorageSync('adminToken')
      const fullUrl = that.globalData.baseUrl + options.url
      
      console.log('管理员端请求:', {
        url: fullUrl,
        method: options.method || 'GET',
        data: options.data || {},
        token: token
      })
      
      wx.request({
        url: fullUrl,
        method: options.method || 'GET',
        data: options.data || {},
        header: {
          'content-type': 'application/json',
          'Authorization': 'Bearer ' + (token || '')
        },
        success: (res) => {
          console.log('管理员端请求成功:', res)
          if (res.statusCode === 200) {
            if (res.data.code === 1) {
              resolve(res.data)
            } else {
              console.log('管理员端请求失败:', res.data)
              wx.showToast({
                title: res.data.msg || '请求失败',
                icon: 'none'
              })
              reject(res.data)
            }
          } else if (res.statusCode === 401) {
            // token过期，清除token并提示重新登录
            console.log('管理员Token过期，需要重新登录')
            that.adminLogout()
            wx.showToast({
              title: '登录已过期，请重新登录',
              icon: 'none'
            })
            reject(res.data)
          } else {
            console.log('HTTP错误:', res.statusCode)
            wx.showToast({
              title: '网络错误',
              icon: 'none'
            })
            reject(res.data)
          }
        },
        fail: (err) => {
          console.log('管理员端请求失败:', err)
          wx.showToast({
            title: '网络错误',
            icon: 'none'
          })
          reject(err)
        }
      })
    })
  },

  // 用户端请求方法（完全按照原来用户端小程序的逻辑）
  userRequest(options) {
    const that = this
    return new Promise((resolve, reject) => {
      const token = wx.getStorageSync('token') // 使用原来的token键名
      const fullUrl = that.globalData.userApiUrl + options.url
      
      console.log('=== 用户端请求开始 ===')
      console.log('请求URL:', fullUrl)
      console.log('请求方法:', options.method || 'GET')
      console.log('请求数据:', options.data || {})
      console.log('用户Token:', token ? token.substring(0, 20) + '...' : '无token')
      console.log('请求头:', {
        'content-type': 'application/json',
        'Authorization': 'Bearer ' + (token || '')
      })
      
      wx.request({
        url: fullUrl,
        method: options.method || 'GET',
        data: options.data || {},
        header: {
          'content-type': 'application/json',
          'Authorization': 'Bearer ' + (token || '')
        },
        success: (res) => {
          console.log('=== 用户端请求响应 ===')
          console.log('HTTP状态码:', res.statusCode)
          console.log('响应数据:', res.data)
          console.log('响应头:', res.header)
          
          if (res.statusCode === 200) {
            if (res.data.code === 1) {
              console.log('请求成功，返回数据:', res.data)
              resolve(res.data)
            } else {
              console.log('=== 业务逻辑错误 ===')
              console.log('错误代码:', res.data.code)
              console.log('错误消息:', res.data.msg)
              console.log('完整错误响应:', JSON.stringify(res.data, null, 2))
              // 不在这里显示toast，让调用方处理
              reject(res.data)
            }
          } else if (res.statusCode === 401) {
            console.log('=== Token过期错误 ===')
            console.log('HTTP状态码: 401')
            console.log('响应数据:', res.data)
            // token过期，重新登录
            console.log('用户Token过期，重新登录')
            that.autoLogin()
            reject(res.data)
          } else {
            console.log('=== HTTP错误 ===')
            console.log('HTTP状态码:', res.statusCode)
            console.log('响应数据:', res.data)
            wx.showToast({
              title: '网络错误',
              icon: 'none'
            })
            reject(res.data)
          }
        },
        fail: (err) => {
          console.log('用户端请求失败:', err)
          wx.showToast({
            title: '网络错误',
            icon: 'none'
          })
          reject(err)
        }
      })
    })
  },

  // 管理员端登录
  adminLogin(adminInfo) {
    return this.request({
      url: '/adminLogin',
      method: 'POST',
      data: adminInfo
    }).then(res => {
      if (res.data && res.data.token) {
        this.globalData.token = res.data.token
        this.globalData.adminInfo = res.data.admin_info // 设置管理员信息
        this.globalData.isUserMode = false
        wx.setStorageSync('adminToken', res.data.token)
        wx.setStorageSync('adminInfo', res.data.admin_info) // 保存管理员信息
        
        // 登录成功后，加载管理员权限数据
        this.loadAdminPermissions(res.data.admin_info.id, res.data.token)
      }
      return res
    })
  },

  // 管理员端登出
  adminLogout() {
    this.globalData.token = null
    this.globalData.adminInfo = null // 清除管理员信息
    this.globalData.isUserMode = false
    wx.removeStorageSync('adminToken')
    wx.removeStorageSync('adminInfo') // 清除存储的管理员信息
  },

  // 用户端自动登录（完全按照原来用户端小程序的逻辑）
  autoLogin() {
    const that = this
    return new Promise((resolve, reject) => {
      wx.login({
        success: (res) => {
          if (res.code) {
            that.userRequest({
              url: '/autoLogin',
              method: 'POST',
              data: {
                code: res.code
              }
            }).then((result) => {
              console.log('autoLogin API返回结果:', result)
              
              if (result.data && result.data.token) {
                // 登录成功，设置token和用户信息
                that.globalData.token = result.data.token
                that.globalData.userInfo = result.data.user
                that.globalData.isUserMode = true
                wx.setStorageSync('token', result.data.token)
                wx.setStorageSync('userInfo', result.data.user)
                resolve(result)
              } else if (result.data && result.data.msg === '需要绑定账号') {
                // 需要绑定账号，自动创建新用户
                console.log('需要绑定账号，自动创建新用户')
                that.autoCreateUser(result.data)
                  .then(resolve)
                  .catch(reject)
              } else if (result.code === 1 && result.msg === '需要绑定账号') {
                // 检查result本身是否有这些字段
                console.log('需要绑定账号（从result根级别检查），自动创建新用户')
                that.autoCreateUser(result.data)
                  .then(resolve)
                  .catch(reject)
              } else {
                console.log('API返回数据:', result)
                reject(new Error('登录失败：没有返回token'))
              }
            }).catch((err) => {
              console.error('自动登录失败:', err)
              reject(err)
            })
          } else {
            reject(new Error('微信登录失败'))
          }
        },
        fail: (err) => {
          console.error('微信登录失败:', err)
          reject(err)
        }
      })
    })
  },

  // 用户端登录
  userLogin(userInfo = {}) {
    // 如果没有提供用户信息，检查本地存储
    if (!userInfo.code && !userInfo.userInfo) {
      const storedUserInfo = wx.getStorageSync('userInfo')
      const storedUserToken = wx.getStorageSync('token') // 使用原来的token键名
      
      if (storedUserInfo && storedUserToken) {
        // 使用存储的信息
        this.globalData.token = storedUserToken
        this.globalData.isUserMode = true
        return Promise.resolve({ data: { token: storedUserToken, user_info: storedUserInfo } })
      } else {
        return Promise.reject(new Error('没有用户登录信息'))
      }
    }
    
    return this.userRequest({
      url: '/autoLogin',
      method: 'POST',
      data: userInfo
    }).then(res => {
      if (res.data && res.data.token) {
        this.globalData.token = res.data.token
        this.globalData.isUserMode = true
        wx.setStorageSync('token', res.data.token)
        wx.setStorageSync('userInfo', res.data.user_info)
      }
      return res
    })
  },

  // 用户端登出
  userLogout() {
    this.globalData.token = null
    this.globalData.userInfo = null
    this.globalData.isUserMode = false
    wx.removeStorageSync('token') // 使用原来的token键名
    wx.removeStorageSync('userInfo')
  },

  // 切换到用户模式
  switchToUserMode() {
    this.globalData.isUserMode = true
  },

  // 切换到管理员模式
  switchToAdminMode() {
    this.globalData.isUserMode = false
  },

  // 启动消息轮询
  startMessagePolling() {
    // 清除之前的定时器
    if (this.globalData.messagePollingTimer) {
      clearInterval(this.globalData.messagePollingTimer)
    }
    
    // 每15秒检查一次新消息
    this.globalData.messagePollingTimer = setInterval(() => {
      this.checkNewMessages()
    }, 15000)
  },

  // 检查新消息
  checkNewMessages() {
    if (!this.checkUserLogin()) return
    
    this.userRequest({
      url: '/checkNewMessages',
      method: 'GET',
      data: {
        last_check: this.globalData.lastMessageCheck
      }
    }).then((res) => {
      if (res.data.hasNew) {
        // 有新消息，显示通知
        this.showMessageNotification(res.data.messages)
        this.globalData.lastMessageCheck = Date.now()
        
        // 更新全局未读消息数量
        this.updateGlobalUnreadCount(res.data.unreadCount || 0)
      }
    }).catch((err) => {
      console.error('检查新消息失败:', err)
    })
  },

  // 更新全局未读消息数量
  updateGlobalUnreadCount(count) {
    this.globalData.unreadCount = count
    // 触发自定义事件，通知所有页面更新
    wx.getApp().globalData.unreadCount = count
  },

  // 显示消息通知
  showMessageNotification(messages) {
    messages.forEach(message => {
      if (message.type === 'allocation') {
        // 分工通知 - 使用更醒目的提示
        wx.showModal({
          title: '🎯 新任务分配',
          content: `您有新的任务分配：${message.title}\n\n点击"查看详情"立即处理`,
          confirmText: '查看详情',
          cancelText: '稍后查看',
          confirmColor: '#3cc51f',
          success: (res) => {
            if (res.confirm) {
              // 跳转到任务页面
              wx.switchTab({
                url: '/pages/user-tasks/user-tasks'
              })
            }
          }
        })
      } else if (message.type === 'audit') {
        // 审核通知
        wx.showModal({
          title: '📋 报工审核通知',
          content: `您的报工记录已审核：${message.title}`,
          confirmText: '查看详情',
          cancelText: '知道了',
          confirmColor: '#3cc51f',
          success: (res) => {
            if (res.confirm) {
              wx.switchTab({
                url: '/pages/user-records/user-records'
              })
            }
          }
        })
      } else {
        // 其他类型消息 - 使用Toast提示
        wx.showToast({
          title: message.title,
          icon: 'none',
          duration: 3000
        })
      }
    })
  },

  // 停止消息轮询
  stopMessagePolling() {
    if (this.globalData.messagePollingTimer) {
      clearInterval(this.globalData.messagePollingTimer)
      this.globalData.messagePollingTimer = null
    }
  },

  // 检查管理员登录状态
  checkAdminLogin() {
    const token = wx.getStorageSync('adminToken')
    const adminInfo = wx.getStorageSync('adminInfo')
    if (token && adminInfo) {
      this.globalData.token = token
      this.globalData.adminInfo = adminInfo
      
      // 如果管理员信息中没有权限数据，则重新获取
      if (!adminInfo.permissions) {
        this.loadAdminPermissions(adminInfo.id, token)
      }
      
      console.log('管理员登录状态检查成功:', {
        token: token ? token.substring(0, 10) + '...' : null,
        adminInfo: adminInfo ? { id: adminInfo.id, username: adminInfo.username } : null
      })
      
      return true
    }
    
    console.log('管理员登录状态检查失败: 没有token或adminInfo')
    return false
  },

  // 检查用户登录状态（完全按照原来用户端小程序的逻辑）
  checkUserLogin() {
    const token = wx.getStorageSync('token') // 使用原来的token键名
    if (token) {
      this.globalData.token = token
      this.globalData.userInfo = wx.getStorageSync('userInfo')
      return true
    }
    return false
  },

  // 检查token是否有效
  checkToken() {
    const adminInfo = wx.getStorageSync('adminInfo')
    const token = wx.getStorageSync('adminToken')
    
    if (adminInfo && token) {
      this.globalData.adminInfo = adminInfo
      
      // 如果管理员信息中没有权限数据，则重新获取
      if (!adminInfo.permissions) {
        this.loadAdminPermissions(adminInfo.id, token)
      }
      
      // 验证token有效性
      const api = require('./utils/api.js')
      api.checkToken().catch(err => {
        // token无效，清除本地存储
        wx.removeStorageSync('adminInfo')
        wx.removeStorageSync('adminToken')
        this.globalData.adminInfo = null
        this.globalData.token = ''
        
        // 跳转到登录页
        wx.reLaunch({
          url: '/pages/login/login'
        })
      })
    }
  },

  // 加载管理员权限数据
  loadAdminPermissions(adminId, token) {
    wx.request({
      url: this.globalData.baseUrl + '/getAdminDetail',
      method: 'GET',
      data: { id: adminId },
      header: {
        'content-type': 'application/json',
        'Authorization': 'Bearer ' + token
      },
      success: (res) => {
        if (res.statusCode === 200 && res.data.code === 1) {
          console.log('获取到的管理员权限数据:', res.data.data.rule_list)
          
          // 从rule_list解析权限数据
          let permissions = {}
          if (res.data.data.rule_list && Array.isArray(res.data.data.rule_list)) {
            res.data.data.rule_list.forEach(rule => {
              const parts = rule.split('/')
              if (parts.length === 2) {
                const module = parts[0]
                const action = parts[1]
                
                if (!permissions[module]) {
                  permissions[module] = []
                }
                if (!permissions[module].includes(action)) {
                  permissions[module].push(action)
                }
              }
            })
          }
          
          console.log('解析后的权限数据:', permissions)
          
          const adminInfoWithPermissions = {
            ...this.globalData.adminInfo,
            permissions: permissions
          }
          
          // 更新全局数据和本地存储
          this.globalData.adminInfo = adminInfoWithPermissions
          wx.setStorageSync('adminInfo', adminInfoWithPermissions)
          
          console.log('管理员权限加载成功:', permissions)
        }
      },
      fail: (err) => {
        console.warn('加载权限数据失败:', err)
      }
    })
  },

  // 自动创建用户
  autoCreateUser(wechatData) {
    console.log('自动创建用户，微信数据:', wechatData)
    
    // 跳转到编辑资料页面，传递微信数据
    wx.reLaunch({
      url: `/pages/user-edit/user-edit?mode=create&openid=${wechatData.openid}&session_key=${wechatData.session_key}`
    })
    
    // 返回一个Promise，这样调用方可以等待结果
    return new Promise((resolve, reject) => {
      // 这里不直接resolve，因为用户编辑资料后才会创建成功
      // 我们只是跳转页面，实际的创建逻辑在编辑页面
      reject(new Error('跳转到编辑资料页面'))
    })
  }
}) 